home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / prg_casm / vidmgr13.zip / VMGRWNT.C < prev   
C/C++ Source or Header  |  1996-10-03  |  14KB  |  568 lines
  1. /*
  2.  *  VMGRWNT.C; VidMgr module for Windows 95/NT compilers.  Release 1.3.
  3.  *
  4.  *  This module written in May 1996 by Andrew Clarke and released to the
  5.  *  public domain.  Last modified in October 1996.
  6.  */
  7.  
  8. #include <stdlib.h>
  9. #include <string.h>
  10.  
  11. #define WIN32_LEAN_AND_MEAN
  12.  
  13. #include <windows.h>
  14. #include "vidmgr.h"
  15.  
  16. #ifdef __CYGWIN32__
  17. typedef WORD far *LPWORD;
  18. #endif
  19.  
  20. static HANDLE HInput = INVALID_HANDLE_VALUE;
  21. static HANDLE HOutput = INVALID_HANDLE_VALUE;
  22. static unsigned long key_hit = 0xFFFFFFFFUL;
  23.  
  24. static int video_init = 0;
  25.  
  26. #define vi_init()  if (!video_init) vm_vi_init()
  27. #define vi_done()  if (video_init) vm_vi_done()
  28.  
  29. void vm_vi_init(void)
  30. {
  31.     HInput = GetStdHandle(STD_INPUT_HANDLE);
  32.     HOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  33.     video_init = 1;
  34. }
  35.  
  36. void vm_vi_done(void)
  37. {
  38.     CloseHandle(HInput);
  39.     HInput = INVALID_HANDLE_VALUE;
  40.     CloseHandle(HOutput);
  41.     HOutput = INVALID_HANDLE_VALUE;
  42.     video_init = 0;
  43. }
  44.  
  45. void vm_init(void)
  46. {
  47.     vi_init();
  48.     vm_getinfo(&vm_startup);
  49.     vm_setattr(vm_startup.attr);
  50. }
  51.  
  52. void vm_done(void)
  53. {
  54.     CONSOLE_CURSOR_INFO cci;
  55.     SetConsoleCursorInfo(HOutput, &cci);
  56.     vm_startup.dwSize = (unsigned short)cci.dwSize;
  57.     vm_startup.bVisible = (int)cci.bVisible;
  58.     vi_done();
  59. }
  60.  
  61. void vm_getinfo(struct vm_info *v)
  62. {
  63.     CONSOLE_CURSOR_INFO cci;
  64.     v->ypos = vm_wherey();
  65.     v->xpos = vm_wherex();
  66.     v->attr = vm_getattrxy(v->xpos, v->ypos);
  67.     v->height = vm_getscreenheight();
  68.     v->width = vm_getscreenwidth();
  69.     cci.dwSize = (DWORD) vm_startup.dwSize;
  70.     cci.bVisible = (BOOL) vm_startup.bVisible;
  71.     GetConsoleCursorInfo(HOutput, &cci);
  72. }
  73.  
  74. char vm_getscreenwidth(void)
  75. {
  76.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  77.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  78.     return (char)csbi.dwSize.X;
  79. }
  80.  
  81. char vm_getscreenheight(void)
  82. {
  83.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  84.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  85.     return (char)csbi.dwSize.Y;
  86. }
  87.  
  88. short vm_getscreensize(void)
  89. {
  90.     return (short)(vm_getscreenwidth() * vm_getscreenheight() * 2);
  91. }
  92.  
  93. char vm_wherex(void)
  94. {
  95.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  96.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  97.     return (char)(csbi.dwCursorPosition.X + 1);
  98. }
  99.  
  100. char vm_wherey(void)
  101. {
  102.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  103.     GetConsoleScreenBufferInfo(HOutput, &csbi);
  104.     return (char)(csbi.dwCursorPosition.Y + 1);
  105. }
  106.  
  107. void vm_gotoxy(char x, char y)
  108. {
  109.     COORD dwCursorPosition;
  110.     dwCursorPosition.X = (SHORT) (x - 1);
  111.     dwCursorPosition.Y = (SHORT) (y - 1);
  112.     SetConsoleCursorPosition(HOutput, dwCursorPosition);
  113. }
  114.  
  115. int vm_kbhit(void)
  116. {
  117.     int iKey = 0;
  118.     INPUT_RECORD irBuffer;
  119.     DWORD pcRead;
  120.  
  121.     if (key_hit != 0xFFFFFFFFUL)
  122.     {
  123.         return (int)key_hit;
  124.     }
  125.  
  126.     memset(&irBuffer, 0, sizeof irBuffer);
  127.  
  128.     if (WaitForSingleObject(HInput, 0L) == 0)
  129.     {
  130.         ReadConsoleInput(HInput, &irBuffer, 1, &pcRead);
  131.         if (irBuffer.EventType == KEY_EVENT &&
  132.           irBuffer.Event.KeyEvent.bKeyDown != 0 &&
  133.           irBuffer.Event.KeyEvent.wRepeatCount <= 1)
  134.         {
  135.             WORD vk, vs, uc;
  136.             BOOL fShift, fAlt, fCtrl;
  137.  
  138.             vk = irBuffer.Event.KeyEvent.wVirtualKeyCode;
  139.             vs = irBuffer.Event.KeyEvent.wVirtualScanCode;
  140. #ifdef __CYGWIN32__
  141.             uc = irBuffer.Event.KeyEvent.AsciiChar;
  142. #else
  143.             uc = irBuffer.Event.KeyEvent.uChar.AsciiChar;
  144. #endif
  145.  
  146.             fShift = (irBuffer.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED);
  147.             fAlt = (irBuffer.Event.KeyEvent.dwControlKeyState & (RIGHT_ALT_PRESSED + LEFT_ALT_PRESSED));
  148.             fCtrl = (irBuffer.Event.KeyEvent.dwControlKeyState & (RIGHT_CTRL_PRESSED + LEFT_CTRL_PRESSED));
  149.  
  150.             if (uc == 0)
  151.             {                   /* function keys */
  152.                 switch (vk)
  153.                 {
  154.                 case 0x21:     /* PgUp */
  155.                     if (fCtrl)
  156.                     {
  157.                         vs = 0x84;  /* Ctrl+PgUp */
  158.                     }
  159.                     break;
  160.  
  161.                 case 0x22:     /* PgDn */
  162.                     if (fCtrl)
  163.                     {
  164.                         vs = 0x76;  /* Ctrl+PgDn */
  165.                     }
  166.                     break;
  167.  
  168.                 case 0x23:     /* End */
  169.                     if (fCtrl)
  170.                     {
  171.                         vs = 0x75;  /* Ctrl+End */
  172.                     }
  173.                     break;
  174.  
  175.                 case 0x24:     /* Home */
  176.                     if (fCtrl)
  177.                     {
  178.                         vs = 0x77;  /* Ctrl+Home */
  179.                     }
  180.                     break;
  181.  
  182.                 case 0x25:     /* Left Arrow */
  183.                     if (fCtrl)
  184.                     {
  185.                         vs = 0x73;  /* Ctrl+Left Arrow */
  186.                     }
  187.                     break;
  188.  
  189.                 case 0x26:     /* Up Arrow */
  190.                     if (fCtrl)
  191.                     {
  192.                         vs = 0x8d;  /* Ctrl+Up Arrow */
  193.                     }
  194.                     break;
  195.  
  196.                 case 0x27:     /* Right Arrow */
  197.                     if (fCtrl)
  198.                     {
  199.                         vs = 0x74;  /* Ctrl+Right Arrow */
  200.                     }
  201.                     break;
  202.  
  203.                 case 0x28:     /* Down Arrow */
  204.                     if (fCtrl)
  205.                     {
  206.                         vs = 0x91;  /* Ctrl+Down Arrow */
  207.                     }
  208.                     break;
  209.  
  210.                 case 0x70:     /* F-Keys */
  211.                 case 0x71:
  212.                 case 0x72:
  213.                 case 0x73:
  214.                 case 0x74:
  215.                 case 0x75:
  216.                 case 0x76:
  217.                 case 0x77:
  218.                 case 0x78:
  219.                 case 0x79:
  220.                     if (fAlt)
  221.                     {
  222.                         vs += 0x2d;  /* Alt+F-Key */
  223.                     }
  224.                     else if (fShift)
  225.                     {
  226.                         vs += 0x19;  /* Shift+F-Key */
  227.                     }
  228.                     break;
  229.                 }
  230.  
  231.                 if (vk > 0x20 && vk < 0x92)  /* If it's OK use scan code */
  232.                 {
  233.                     iKey = vs << 8;
  234.                 }
  235.             }
  236.             else
  237.             {
  238.                 if (fAlt)       /* Alt+Key */
  239.                 {
  240.                     iKey = vs << 8;
  241.                 }
  242.                 else if (fCtrl) /* Ctrl+Key */
  243.                 {
  244.                     iKey = vk & 0xbf;
  245.                 }
  246.                 else
  247.                 {
  248.                     iKey = uc;
  249.                 }
  250.             }
  251.         }
  252.     }
  253.  
  254.     if (iKey != 0)
  255.     {
  256.         key_hit = iKey;
  257.     }
  258.  
  259.     return (int)iKey;
  260. }
  261.  
  262. int vm_getch(void)
  263. {
  264.     int iKey;
  265.     while (key_hit == 0xFFFFFFFFUL)
  266.     {
  267.         vm_kbhit();
  268.     }
  269.     iKey = key_hit;
  270.     key_hit = 0xFFFFFFFFUL;
  271.     return (int)iKey;
  272. }
  273.  
  274. char vm_getchxy(char x, char y)
  275. {
  276.     char ch;
  277.     DWORD len;
  278.     COORD coord;
  279.     coord.X = (DWORD) (x - 1);
  280.     coord.Y = (DWORD) (y - 1);
  281.     ReadConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  282.     return ch;
  283. }
  284.  
  285. char vm_getattrxy(char x, char y)
  286. {
  287.     DWORD len;
  288.     COORD coord;
  289.     WORD wattr;
  290.     coord.X = (DWORD) (x - 1);
  291.     coord.Y = (DWORD) (y - 1);
  292.     ReadConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  293.     return (char)wattr;
  294. }
  295.  
  296. void vm_xgetchxy(char x, char y, char *attr, char *ch)
  297. {
  298.     DWORD len;
  299.     COORD coord;
  300.     WORD wattr;
  301.     coord.X = (DWORD) (x - 1);
  302.     coord.Y = (DWORD) (y - 1);
  303.     ReadConsoleOutputCharacterA(HOutput, ch, 1, coord, &len);
  304.     ReadConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  305.     *attr = (char)wattr;
  306. }
  307.  
  308. void vm_setcursorstyle(int style)
  309. {
  310.     CONSOLE_CURSOR_INFO cci;
  311.     GetConsoleCursorInfo(HOutput, &cci);
  312.     switch (style)
  313.     {
  314.     case CURSORHALF:
  315.         cci.bVisible = 1;
  316.         cci.dwSize = 49;
  317.         SetConsoleCursorInfo(HOutput, &cci);
  318.         break;
  319.     case CURSORFULL:
  320.         cci.bVisible = 1;
  321.         cci.dwSize = 99;
  322.         SetConsoleCursorInfo(HOutput, &cci);
  323.         break;
  324.     case CURSORNORM:
  325.         cci.bVisible = 1;
  326.         cci.dwSize = 12;
  327.         SetConsoleCursorInfo(HOutput, &cci);
  328.         break;
  329.     case CURSORHIDE:
  330.         cci.bVisible = 0;
  331.         SetConsoleCursorInfo(HOutput, &cci);
  332.         break;
  333.     default:
  334.         break;
  335.     }
  336. }
  337.  
  338. void vm_putch(char x, char y, char ch)
  339. {
  340.     DWORD len;
  341.     COORD coord;
  342.     coord.X = (DWORD) (x - 1);
  343.     coord.Y = (DWORD) (y - 1);
  344.     WriteConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  345. }
  346.  
  347. void vm_puts(char x, char y, char *str)
  348. {
  349.     DWORD len;
  350.     COORD coord;
  351.     coord.X = (DWORD) (x - 1);
  352.     coord.Y = (DWORD) (y - 1);
  353.     WriteConsoleOutputCharacterA(HOutput, str, (DWORD) strlen(str), coord, &len);
  354. }
  355.  
  356. void vm_xputch(char x, char y, char attr, char ch)
  357. {
  358.     DWORD len;
  359.     COORD coord;
  360.     WORD wattr;
  361.     coord.X = (DWORD) (x - 1);
  362.     coord.Y = (DWORD) (y - 1);
  363.     wattr = attr;
  364.     WriteConsoleOutputCharacterA(HOutput, &ch, 1, coord, &len);
  365.     WriteConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  366. }
  367.  
  368. void vm_xputs(char x, char y, char attr, char *str)
  369. {
  370.     DWORD i, len;
  371.     COORD coord;
  372.     LPWORD pwattr;
  373.     pwattr = malloc(strlen(str) * sizeof(*pwattr));
  374.     if (!pwattr)
  375.     {
  376.         return;
  377.     }
  378.     coord.X = (DWORD) (x - 1);
  379.     coord.Y = (DWORD) (y - 1);
  380.     for (i = 0; i < strlen(str); i++)
  381.     {
  382.         *(pwattr + i) = attr;
  383.     }
  384.     WriteConsoleOutputCharacterA(HOutput, str, (DWORD) strlen(str), coord, &len);
  385.     WriteConsoleOutputAttribute(HOutput, pwattr, (DWORD) strlen(str), coord, &len);
  386.     free(pwattr);
  387. }
  388.  
  389. void vm_putattr(char x, char y, char attr)
  390. {
  391.     DWORD len;
  392.     COORD coord;
  393.     WORD wattr;
  394.     coord.X = (DWORD) (x - 1);
  395.     coord.Y = (DWORD) (y - 1);
  396.     wattr = attr;
  397.     WriteConsoleOutputAttribute(HOutput, &wattr, 1, coord, &len);
  398. }
  399.  
  400. void vm_paintclearbox(char x1, char y1, char x2, char y2, char attr)
  401. {
  402.     COORD coord;
  403.     LPWORD pwattr;
  404.     char y, *pstr;
  405.     DWORD i, len, width;
  406.     width = (x2 - x1 + 1);
  407.     pwattr = malloc(width * sizeof(*pwattr));
  408.     if (!pwattr)
  409.     {
  410.         return;
  411.     }
  412.     pstr = malloc(width);
  413.     if (!pstr)
  414.     {
  415.         free(pwattr);
  416.         return;
  417.     }
  418.     for (i = 0; i < width; i++)
  419.     {
  420.         *(pwattr + i) = attr;
  421.         *(pstr + i) = ' ';
  422.     }
  423.     for (y = y1; y <= y2; y++)
  424.     {
  425.         coord.X = (DWORD) (x1 - 1);
  426.         coord.Y = (DWORD) (y - 1);
  427.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  428.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  429.     }
  430.     free(pwattr);
  431.     free(pstr);
  432. }
  433.  
  434. void vm_paintbox(char x1, char y1, char x2, char y2, char attr)
  435. {
  436.     DWORD i, len, width;
  437.     COORD coord;
  438.     LPWORD pwattr;
  439.     char y;
  440.     width = (x2 - x1 + 1);
  441.     pwattr = malloc(width * sizeof(*pwattr));
  442.     if (!pwattr)
  443.     {
  444.         return;
  445.     }
  446.     for (i = 0; i < width; i++)
  447.     {
  448.         *(pwattr + i) = attr;
  449.     }
  450.     for (y = y1; y <= y2; y++)
  451.     {
  452.         coord.X = (DWORD) (x1 - 1);
  453.         coord.Y = (DWORD) (y - 1);
  454.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  455.     }
  456.     free(pwattr);
  457. }
  458.  
  459. void vm_clearbox(char x1, char y1, char x2, char y2)
  460. {
  461.     vm_fillbox(x1, y1, x2, y2, ' ');
  462. }
  463.  
  464. void vm_fillbox(char x1, char y1, char x2, char y2, char ch)
  465. {
  466.     DWORD i, len, width;
  467.     COORD coord;
  468.     char y, *pstr;
  469.     width = (x2 - x1 + 1);
  470.     pstr = malloc(width);
  471.     if (!pstr)
  472.     {
  473.         return;
  474.     }
  475.     for (i = 0; i < width; i++)
  476.     {
  477.         *(pstr + i) = ch;
  478.     }
  479.     for (y = y1; y <= y2; y++)
  480.     {
  481.         coord.X = (DWORD) (x1 - 1);
  482.         coord.Y = (DWORD) (y - 1);
  483.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  484.     }
  485.     free(pstr);
  486. }
  487.  
  488. void vm_gettext(char x1, char y1, char x2, char y2, char *dest)
  489. {
  490.     DWORD i, len, width;
  491.     COORD coord;
  492.     LPWORD pwattr;
  493.     char y, *pstr;
  494.     width = (x2 - x1 + 1);
  495.     pwattr = malloc(width * sizeof(*pwattr));
  496.     if (!pwattr)
  497.     {
  498.         return;
  499.     }
  500.     pstr = malloc(width);
  501.     if (!pstr)
  502.     {
  503.         free(pwattr);
  504.         return;
  505.     }
  506.     for (y = y1; y <= y2; y++)
  507.     {
  508.         coord.X = (DWORD) (x1 - 1);
  509.         coord.Y = (DWORD) (y - 1);
  510.         ReadConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  511.         ReadConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  512.         for (i = 0; i < width; i++)
  513.         {
  514.             *dest = *(pstr + i);
  515.             dest++;
  516.             *dest = (char)*(pwattr + i);
  517.             dest++;
  518.         }
  519.     }
  520.     free(pwattr);
  521.     free(pstr);
  522. }
  523.  
  524. void vm_puttext(char x1, char y1, char x2, char y2, char *srce)
  525. {
  526.     DWORD i, len, width;
  527.     COORD coord;
  528.     LPWORD pwattr;
  529.     char y, *pstr;
  530.     width = (x2 - x1 + 1);
  531.     pwattr = malloc(width * sizeof(*pwattr));
  532.     if (!pwattr)
  533.     {
  534.         return;
  535.     }
  536.     pstr = malloc(width);
  537.     if (!pstr)
  538.     {
  539.         free(pwattr);
  540.         return;
  541.     }
  542.     for (y = y1; y <= y2; y++)
  543.     {
  544.         for (i = 0; i < width; i++)
  545.         {
  546.             *(pstr + i) = *srce;
  547.             srce++;
  548.             *(pwattr + i) = *srce;
  549.             srce++;
  550.         }
  551.         coord.X = (DWORD) (x1 - 1);
  552.         coord.Y = (DWORD) (y - 1);
  553.         WriteConsoleOutputCharacterA(HOutput, pstr, width, coord, &len);
  554.         WriteConsoleOutputAttribute(HOutput, pwattr, width, coord, &len);
  555.     }
  556.     free(pwattr);
  557.     free(pstr);
  558. }
  559.  
  560. void vm_horizline(char x1, char x2, char row, char attr, char ch)
  561. {
  562.     char x;
  563.     for (x = x1; x <= x2; x++)
  564.     {
  565.         vm_xputch(x, row, attr, ch);
  566.     }
  567. }
  568.